officeparser 7.6.1 → 7.7.0

package/README.md

@@ -780,6 +780,8 @@ idempotent and `.md → AST → HTML → AST → .md` survives unchanged.
 | Attribute lists | `![alt](img.png){width=50% .centered}` | `ImageMetadata.width` / `.align`, `TableMetadata.align` |
 | Citations | `[@smith2024]` | `TextMetadata.citationKey` |
 | Wikilinks | `[[Page]]` / `[[Page\|Alias]]` | `TextMetadata.wikilink`, `.link`, `.linkType` |
+| Highlight | `==text==` | `TextMetadata.backgroundColor` |
+| Link/image titles | `[text](url "Title")` / `![alt](img.png "Title")` | `TextMetadata.title` / `ImageMetadata.title` |
 | Inline/block math | `$E=mc^2$` / `` $$...$$ `` | `type: 'code'`, `CodeMetadata.math` (`'inline' \| 'block'`) |
 | Frontmatter arrays | `tags: [a, b]` or `tags: ["a","b"]` | Real array in `metadata.customProperties`/`nativeProperties` |
 | MDX components (import-only) | `<Component prop="x">...</Component>` | Stripped; inner Markdown is kept. Never generated back. |
@@ -795,7 +797,8 @@ save→reload cycle:
 | HTML attribute | AST field | Notes |
 |---|---|---|
 | `data-width` / `data-align` / inline `style="width:…"` on `<img>` | `ImageMetadata.width` / `.align` | |
-| `data-align` on `<table>` | `TableMetadata.align` | |
+| `data-align` on `<table>` | `TableMetadata.align` | Emitted/parsed as per-column GFM markers (`:---`, `:---:`, `---:`); alignment rides `CellMetadata.align` |
+| `title` on `<a>` / `<img>` | `TextMetadata.title` / `ImageMetadata.title` | Survives both directions (`[text](url "Title")` in Markdown) |
 | `colspan` / `rowspan` on `<td>`/`<th>` | `CellMetadata.colSpan` / `.rowSpan` | Previously dropped on HTML import — merged cells now survive a save→reload cycle |
 | `<div data-youtube-video="ID">` / `<iframe src="...youtube.com...">` | `type: 'embed'` | |
 | `<ul data-type="taskList">` / `<li data-checked>` | `ListMetadata.isTask` / `.checked` | |
@@ -1000,7 +1003,7 @@ Options shared by all generator formats. Pass to `OfficeGenerator.generate(ast,
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `includeFormatting` | `boolean` | `true` | Include bold/italic/colors/sizes in output |
-| `generateIds` | `boolean` | `true` | Add slug-based `id` attributes to headings |
+| `generateIds` | `boolean` | `true` | Slug-based heading anchors: `id` attributes on HTML headings, and a `{#slug}` suffix on Markdown headings (`# Title {#title}`, kramdown/Pandoc). Set `false` to omit both — useful when the Markdown is rendered by GFM/CommonMark, which show `{#slug}` as literal text. Applies to all generator formats (it is a top-level option, not under `mdConfig`/`htmlConfig`). |
 | `renderMetadata` | `boolean` | `false` | Render title/author as visible header block |
 | `metadataOverrides` | `MetadataOverrides` | `{}` | Override the metadata embedded in the output, merged per field over `ast.metadata` |
 | `includeImages` | `boolean` | `true` | Include image nodes in output |
@@ -1146,7 +1149,8 @@ Pass as `mdConfig` inside `GeneratorConfig`.
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `fallbackToHtml` | `boolean \| FallbackToHtmlConfig` | `true` | Use HTML tags for features Markdown cannot represent (underlines, merged table cells, embeds, etc.). Pass an object for per-feature control. `inlineFormatting` (default `false`, opt-in even when the boolean is `true`) additionally round-trips inline color/highlight/font-size as `<span style="...">` runs. |
+| `fallbackToHtml` | `boolean \| FallbackToHtmlConfig` | `true` | Use HTML tags for features Markdown cannot represent (underlines, merged table cells, embeds, etc.). Pass an object for per-feature control. `cellLineBreaks`/`itemLineBreaks` (default on) join multi-line table-cell / multi-paragraph list-item content with `<br>` instead of a space. `inlineFormatting` (default `false`, opt-in even when the boolean is `true`) additionally round-trips inline color/highlight/font-size as `<span style="...">` runs. |
+| `dialect` | `MarkdownDialectPreset \| MarkdownDialectConfig` | `'extended'` | Which native syntax to emit for constructs that differ across targets (GitHub/GitLab/Obsidian/Pandoc/CommonMark). Each capability is typed by the syntax it selects (e.g. `strikethrough: 'tilde'`, `highlight: 'equals'`, `admonitions: 'blockquote'`), with `'none'` to turn it off. See [Markdown Dialect Support](#markdown-dialect-support). The old `boolean` toggles and admonition flavour names (`'github'`/`'gitlab'`/`'pandoc'`) still work but are deprecated. |
 
 ### PdfGeneratorConfig
 

package/dist/generators/HtmlGenerator.js

@@ -446,7 +446,11 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
      */
     async processNodeArray(nodes) {
         let html = '';
-        // Stack to track active lists: { indentation, type, isTask }
+        // Stack to track active lists. `liClose` is the currently-open item's deferred closing
+        // suffix (`</li>`, or `</div></li>` for a task item): a list item is rendered WITHOUT its
+        // close so a deeper list can land inside it (spec-valid `<li>a<ul>...</ul></li>` rather
+        // than the invalid `<li>a</li><ul>...</ul>` sibling shape). The close is emitted when a
+        // same-level sibling arrives, when the level is popped, or at the end.
         const listStack = [];
         const openListTag = (type, isTask) => {
             if (isTask)
@@ -457,7 +461,7 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
         const closeListsToLevel = (level) => {
             while (listStack.length > 0 && listStack[listStack.length - 1].indentation > level) {
                 const list = listStack.pop();
-                html += closeListTag(list.type) + '\n\n';
+                html += list.liClose + closeListTag(list.type) + '\n\n';
             }
         };
         for (const node of nodes) {
@@ -492,20 +496,32 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                 closeListsToLevel(indentation);
                 // Handle current level
                 if (listStack.length > 0 && listStack[listStack.length - 1].indentation === indentation) {
-                    if (listStack[listStack.length - 1].type !== type || listStack[listStack.length - 1].isTask !== isTask) {
-                        // Type changed at same level
+                    const top = listStack[listStack.length - 1];
+                    if (top.type !== type || top.isTask !== isTask) {
+                        // Kind changed at the same level: close the open item and the old list,
+                        // then open the replacement list.
                         const last = listStack.pop();
-                        html += closeListTag(last.type) + '\n';
+                        html += last.liClose + closeListTag(last.type) + '\n';
                         html += openListTag(type, isTask) + '\n';
-                        listStack.push({ indentation, type, isTask });
+                        listStack.push({ indentation, type, isTask, liClose: '' });
+                    }
+                    else {
+                        // Sibling at the same level: close the previous item before this one opens.
+                        html += top.liClose;
                     }
                 }
                 else {
-                    // Start a new nested list
+                    // Deeper level (or the first list): open a nested list INSIDE the currently
+                    // open item, leaving the parent <li>'s close pending on its stack frame.
                     html += openListTag(type, isTask) + '\n';
-                    listStack.push({ indentation, type, isTask });
+                    listStack.push({ indentation, type, isTask, liClose: '' });
                 }
                 html += await this.processNodeRecursive(node, this.nodeProcessor.bind(this), override);
+                // Defer this item's close so a nested list can land inside it. A string override is
+                // a complete replacement item that already carries its own close, so add none.
+                listStack[listStack.length - 1].liClose = (typeof override === 'string')
+                    ? ''
+                    : (isTask ? '</div></li>' : '</li>');
             }
             else {
                 // Non-list node closes all active lists
@@ -712,7 +728,8 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                     imgStyleParts.push('display: block', `margin-left: ${ml}`, `margin-right: ${mr}`);
                 }
                 const imgStyleAttr = imgStyleParts.length > 0 ? ` style="${imgStyleParts.join('; ')}"` : '';
-                const img = `<img src="${(0, sanitize_js_1.sanitizeImageUrl)(src)}" alt="${this.escape(node.text || meta?.altText || '')}"${className}${mappedAttrs}${imgDataAttrs}${imgStyleAttr}>`;
+                const imgTitle = meta?.title ? ` title="${this.escape(meta.title)}"` : '';
+                const img = `<img src="${(0, sanitize_js_1.sanitizeImageUrl)(src)}" alt="${this.escape(node.text || meta?.altText || '')}"${imgTitle}${className}${mappedAttrs}${imgDataAttrs}${imgStyleAttr}>`;
                 const content = this.config.includeFormatting ? `<div class="image-container">${img}<div class="caption">${this.escape(attachmentName || '')}</div></div>` : img;
                 return `${extraAnchors}<div${idAttr}>${content}</div>`;
             }
@@ -831,7 +848,12 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                 }
                 const lang = meta?.language ? ` class="language-${this.escape(meta.language)}"` : '';
                 const codeHtml = `<code${lang}>${this.escape(node.text || '')}</code>`;
-                if (node.text && node.text.includes('\n')) {
+                // A `code` node is always block-level (inline code is a monospace text run, emitted
+                // as <code> by formatText). Wrap in <pre> whenever it carries a language or spans
+                // multiple lines; only a bare single-line, language-less code node stays a <span>.
+                // Previously a single-line block (e.g. a one-line ```js) emitted <span><code>, which
+                // re-imports as inline code and which strict CodeBlock parsers (only <pre><code>) miss.
+                if (meta?.language || (node.text && node.text.includes('\n'))) {
                     return `${extraAnchors}<pre${idAttr}${className}${mappedAttrs}${styleAttr}>${codeHtml}</pre>`;
                 }
                 else {
@@ -839,16 +861,19 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                 }
             }
             case 'list': {
+                // The closing suffix (`</div></li>` for a task item, `</li>` otherwise) is emitted
+                // by processNodeArray's list stack, not here, so a nested list can be placed inside
+                // this item before it closes. See `listStack`/`liClose` there.
                 const meta = node.metadata;
                 if (meta?.isTask) {
                     const checkedAttr = ` data-checked="${meta.checked ? 'true' : 'false'}"`;
                     const checkedBool = meta.checked ? ' checked' : '';
-                    return `${extraAnchors}<li${checkedAttr}${idAttr}${className}${mappedAttrs}${styleAttr}><label><input type="checkbox"${checkedBool}><span></span></label><div>${childrenOutput}</div></li>`;
+                    return `${extraAnchors}<li${checkedAttr}${idAttr}${className}${mappedAttrs}${styleAttr}><label><input type="checkbox"${checkedBool}><span></span></label><div>${childrenOutput}`;
                 }
                 const value = (meta?.listType === 'ordered' && typeof meta.itemIndex === 'number')
                     ? ` value="${meta.itemIndex + 1}"`
                     : '';
-                return `${extraAnchors}<li${value}${idAttr}${className}${mappedAttrs}${styleAttr}>${childrenOutput}</li>`;
+                return `${extraAnchors}<li${value}${idAttr}${className}${mappedAttrs}${styleAttr}>${childrenOutput}`;
             }
             case 'table': {
                 // Smart Table Header Detection
@@ -864,9 +889,13 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                     const isHeaderStyle = firstRow.metadata?.style?.toLowerCase().includes('header');
                     const allBold = firstRowCells.length > 0 && firstRowCells.every(c => c.children?.every(child => child.formatting?.bold === true));
                     if (isHeaderStyle || allBold) {
-                        // Re-process children with <thead> wrap for the first row
+                        // Re-process the first row as header cells, wrapped in a <tr>. Without the
+                        // <tr>, the header cells sit directly under <thead> (`<thead><th>…`), which
+                        // is invalid HTML that HtmlParser does not read back as a table row - so a
+                        // md -> HTML -> md round trip lost the header content. `<thead><tr><th>…` is
+                        // valid and self-idempotent.
                         const headOutput = await this.processNodeRecursive(firstRow, async (n, children) => {
-                            return children.replace(/<td/g, '<th').replace(/<\/td>/g, '</th>');
+                            return `<tr>${children.replace(/<td/g, '<th').replace(/<\/td>/g, '</th>')}</tr>`;
                         });
                         const bodyRows = rows.slice(1);
                         const bodyOutput = await this.processNodeArray(bodyRows);
@@ -1162,6 +1191,11 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
         let result = this.escape(text);
         const f = node.formatting;
         if (this.config.includeFormatting && f) {
+            // Inline code: a monospace run becomes `<code>`, not a `font-family: monospace` span, so
+            // an editor keying on <code> sees it and it re-imports as inline code (HtmlParser maps
+            // <code> back to a monospace run). Innermost, so bold/italic wrap it (`<b><code>…`).
+            if (f.font === 'monospace')
+                result = `<code>${result}</code>`;
             // Inside an `<hN>`, the heading's own styling is authoritative. A run that also carries
             // bold and a font size - the normal case for ODF, where a heading's paragraph style is
             // inherited by its runs - would wrap the text in `<b>` the heading already implies and,
@@ -1216,7 +1250,8 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
         else if (meta?.link) {
             const isInternal = meta.linkType !== 'external';
             if (!this.config.ignoreInternalLinks || !isInternal) {
-                result = `<a href="${(0, sanitize_js_1.sanitizeUrl)(meta.link)}"${meta.linkType === 'external' ? ' target="_blank"' : ''}>${result}</a>`;
+                const linkTitle = meta.title ? ` title="${this.escape(meta.title)}"` : '';
+                result = `<a href="${(0, sanitize_js_1.sanitizeUrl)(meta.link)}"${linkTitle}${meta.linkType === 'external' ? ' target="_blank"' : ''}>${result}</a>`;
             }
         }
         if (meta?.abbreviationTitle) {
@@ -1246,6 +1281,12 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
             const meta = node.metadata;
             if (meta.alignment)
                 pushSafe('text-align', meta.alignment);
+            // A table cell's column alignment (GFM `:---`/`:---:`/`---:`) lives on
+            // `CellMetadata.align`, not `alignment`. Emit it as `text-align` on the `<th>`/`<td>`
+            // so `HtmlParser` reads it back and the pipe-table markers survive AST -> HTML -> AST.
+            // An unaligned cell (no `align`) adds nothing, keeping its HTML byte-identical.
+            if (node.type === 'cell' && meta.align)
+                pushSafe('text-align', meta.align);
             if (meta.backgroundColor)
                 pushSafe('background-color', meta.backgroundColor);
             if (meta.verticalAlign)
@@ -1270,7 +1311,9 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                 pushSafe('background-color', f.backgroundColor);
             if (f.size && !options.skipFontSize)
                 pushSafe('font-size', f.size);
-            if (f.font) {
+            // A monospace run is emitted as <code> by formatText, so it must not also become a
+            // font-family style here (that was the old, non-semantic inline-code shape).
+            if (f.font && f.font !== 'monospace') {
                 const safeFont = (0, sanitize_js_1.sanitizeCssValue)(f.font);
                 if (safeFont)
                     styles.push(`font-family: ${safeFont}, sans-serif`);

package/dist/generators/MarkdownGenerator.js

@@ -27,12 +27,12 @@ const foldLines = (value) => String(value ?? '').replace(/[\r\n]+/g, ' ');
  * exactly (every feature on, GitHub-style admonitions) - the backward-compatibility anchor.
  */
 const MARKDOWN_DIALECT_PRESETS = {
-    extended: { admonitions: 'github', definitionLists: true, footnotes: true, citations: true, wikilinks: true, math: 'dollar', attributeLists: true, strikethrough: true, bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
-    github: { admonitions: 'github', definitionLists: false, footnotes: true, citations: false, wikilinks: false, math: 'dollar', attributeLists: false, strikethrough: true, bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
-    gitlab: { admonitions: 'gitlab', definitionLists: false, footnotes: true, citations: false, wikilinks: false, math: 'dollar', attributeLists: false, strikethrough: true, bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
-    obsidian: { admonitions: 'github', definitionLists: false, footnotes: true, citations: false, wikilinks: true, math: 'dollar', attributeLists: false, strikethrough: true, bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
-    pandoc: { admonitions: 'pandoc', definitionLists: true, footnotes: true, citations: true, wikilinks: false, math: 'dollar', attributeLists: true, strikethrough: true, bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
-    commonmark: { admonitions: 'none', definitionLists: false, footnotes: false, citations: false, wikilinks: false, math: 'none', attributeLists: false, strikethrough: false, bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'html' },
+    extended: { admonitions: 'blockquote', definitionLists: 'colon', footnotes: 'caret', citations: 'at', wikilinks: 'double-bracket', math: 'dollar', attributeLists: 'brace', strikethrough: 'tilde', highlight: 'equals', bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
+    github: { admonitions: 'blockquote', definitionLists: 'none', footnotes: 'caret', citations: 'none', wikilinks: 'none', math: 'dollar', attributeLists: 'none', strikethrough: 'tilde', highlight: 'none', bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
+    gitlab: { admonitions: 'fence', definitionLists: 'none', footnotes: 'caret', citations: 'none', wikilinks: 'none', math: 'dollar', attributeLists: 'none', strikethrough: 'tilde', highlight: 'none', bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
+    obsidian: { admonitions: 'blockquote', definitionLists: 'none', footnotes: 'caret', citations: 'none', wikilinks: 'double-bracket', math: 'dollar', attributeLists: 'none', strikethrough: 'tilde', highlight: 'equals', bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
+    pandoc: { admonitions: 'fence-attribute', definitionLists: 'colon', footnotes: 'caret', citations: 'at', wikilinks: 'none', math: 'dollar', attributeLists: 'brace', strikethrough: 'tilde', highlight: 'none', bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'native' },
+    commonmark: { admonitions: 'none', definitionLists: 'none', footnotes: 'none', citations: 'none', wikilinks: 'none', math: 'none', attributeLists: 'none', strikethrough: 'none', highlight: 'none', bulletListMarker: '-', orderedListMarker: '.', emphasisMarker: 'asterisk', tables: 'html' },
 };
 /**
  * Normalizes `MdGeneratorConfig.dialect` into a fully-resolved preset. A string names a preset
@@ -40,6 +40,30 @@ const MARKDOWN_DIALECT_PRESETS = {
  * omitted field falls back to - NOT "whatever preset was ambient before", since config merging
  * replaces the whole `dialect` field rather than layering an object on top of a prior string.
  */
+/**
+ * Coerces a per-capability field to its canonical syntax variant. An omitted value inherits `base`;
+ * a deprecated boolean maps `true` -> `onValue` and `false` -> `'none'` (the two are the only legacy
+ * inputs, dropped next major); an explicit syntax string passes through unchanged.
+ */
+function resolveToggle(value, onValue, base) {
+    if (value === undefined)
+        return base;
+    if (value === true)
+        return onValue;
+    if (value === false)
+        return 'none';
+    return value;
+}
+/** Maps the deprecated admonition flavor aliases to their syntax names; passes syntax names through. */
+function resolveAdmonitions(value, base) {
+    switch (value) {
+        case undefined: return base;
+        case 'github': return 'blockquote';
+        case 'gitlab': return 'fence';
+        case 'pandoc': return 'fence-attribute';
+        default: return value;
+    }
+}
 function resolveDialect(dialect) {
     if (dialect === undefined)
         return MARKDOWN_DIALECT_PRESETS.extended;
@@ -47,14 +71,15 @@ function resolveDialect(dialect) {
         return MARKDOWN_DIALECT_PRESETS[dialect] ?? MARKDOWN_DIALECT_PRESETS.extended;
     const base = MARKDOWN_DIALECT_PRESETS[dialect.extends ?? 'extended'] ?? MARKDOWN_DIALECT_PRESETS.extended;
     return {
-        admonitions: dialect.admonitions ?? base.admonitions,
-        definitionLists: dialect.definitionLists ?? base.definitionLists,
-        footnotes: dialect.footnotes ?? base.footnotes,
-        citations: dialect.citations ?? base.citations,
-        wikilinks: dialect.wikilinks ?? base.wikilinks,
+        admonitions: resolveAdmonitions(dialect.admonitions, base.admonitions),
+        definitionLists: resolveToggle(dialect.definitionLists, 'colon', base.definitionLists),
+        footnotes: resolveToggle(dialect.footnotes, 'caret', base.footnotes),
+        citations: resolveToggle(dialect.citations, 'at', base.citations),
+        wikilinks: resolveToggle(dialect.wikilinks, 'double-bracket', base.wikilinks),
         math: dialect.math ?? base.math,
-        attributeLists: dialect.attributeLists ?? base.attributeLists,
-        strikethrough: dialect.strikethrough ?? base.strikethrough,
+        attributeLists: resolveToggle(dialect.attributeLists, 'brace', base.attributeLists),
+        strikethrough: resolveToggle(dialect.strikethrough, 'tilde', base.strikethrough),
+        highlight: dialect.highlight ?? base.highlight,
         bulletListMarker: dialect.bulletListMarker ?? base.bulletListMarker,
         orderedListMarker: dialect.orderedListMarker ?? base.orderedListMarker,
         emphasisMarker: dialect.emphasisMarker ?? base.emphasisMarker,
@@ -71,6 +96,7 @@ function resolveFallbackToHtml(fallbackToHtml) {
         // inlineFormatting is opt-in only: it is never enabled by the boolean form, since it changes
         // default output. Every other field follows the boolean.
         textFormatting: on, alignment: on, anchors: on, tables: on, embeds: on, cellLineBreaks: on,
+        itemLineBreaks: on,
         inlineFormatting: false,
     });
     if (fallbackToHtml === undefined || typeof fallbackToHtml === 'boolean')
@@ -83,6 +109,7 @@ function resolveFallbackToHtml(fallbackToHtml) {
         tables: fallbackToHtml.tables ?? on.tables,
         embeds: fallbackToHtml.embeds ?? on.embeds,
         cellLineBreaks: fallbackToHtml.cellLineBreaks ?? on.cellLineBreaks,
+        itemLineBreaks: fallbackToHtml.itemLineBreaks ?? on.itemLineBreaks,
         inlineFormatting: fallbackToHtml.inlineFormatting ?? on.inlineFormatting,
     };
 }
@@ -163,10 +190,13 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
      * ImageMetadata/TableMetadata's width/align fields - the canonical form is always
      * `key=value`, matching MarkdownParser's own vocabulary (MARKDOWN_DIALECT.md §15).
      */
-    renderAttributeList(meta) {
-        if (!this.resolvedDialect.attributeLists)
+    renderAttributeList(meta, options = {}) {
+        if (this.resolvedDialect.attributeLists === 'none')
+            return '';
+        if (!meta)
             return '';
-        if (!meta?.width && !meta?.align)
+        const align = options.skipAlign ? undefined : meta.align;
+        if (!meta.width && !align)
             return '';
         const parts = [];
         // Allowlist, not escape. These land in `metadata.width`/`align` on reparse, which the
@@ -182,8 +212,8 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
         if (meta.width && MD_LENGTH_PATTERN.test(String(meta.width).trim())) {
             parts.push(`width=${String(meta.width).trim()}`);
         }
-        if (meta.align && MD_ALIGN_VALUES.has(String(meta.align).trim().toLowerCase())) {
-            parts.push(`align=${String(meta.align).trim().toLowerCase()}`);
+        if (align && MD_ALIGN_VALUES.has(String(align).trim().toLowerCase())) {
+            parts.push(`align=${String(align).trim().toLowerCase()}`);
         }
         if (parts.length === 0)
             return '';
@@ -265,13 +295,37 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     // HTML tag (e.g. <script>) when the Markdown is rendered to HTML.
                     let text = (0, sanitize_js_1.markdownEscapeText)(node.text || '');
                     if (this.config.includeFormatting && node.formatting) {
+                        // Inline code: re-wrap the RAW text in backticks. The content is literal
+                        // inside a code span, so the entity-escaped form above must not show through.
+                        // The fence is one backtick longer than the longest embedded run so an inner
+                        // backtick can't close the span early, padded when the content touches a
+                        // backtick. Done before emphasis so bold/italic wrap the span (`**`code`**`).
+                        // Previously a monospace text node emitted its bare text, dropping the code.
+                        if (node.formatting.font === 'monospace') {
+                            const raw = node.text || '';
+                            const longestRun = Math.max(0, ...(raw.match(/`+/g) || []).map(s => s.length));
+                            const fence = '`'.repeat(longestRun + 1);
+                            const pad = (raw.startsWith('`') || raw.endsWith('`')) ? ' ' : '';
+                            text = `${fence}${pad}${raw}${pad}${fence}`;
+                        }
                         const emphasisAsterisk = this.resolvedDialect.emphasisMarker === 'asterisk';
                         if (node.formatting.bold && !this.inImplicitBold)
                             text = emphasisAsterisk ? `**${text}**` : `__${text}__`;
                         if (node.formatting.italic)
                             text = emphasisAsterisk ? `*${text}*` : `_${text}_`;
-                        if (node.formatting.strikethrough && this.resolvedDialect.strikethrough)
+                        if (node.formatting.strikethrough && this.resolvedDialect.strikethrough !== 'none')
                             text = `~~${text}~~`;
+                        // `==text==` highlight, in dialects that define it (Obsidian/extended). A plain
+                        // highlight (the default yellow) always becomes `==text==`; a highlight carrying
+                        // a SPECIFIC colour stays a background-color <span> when `inlineFormatting` is on,
+                        // so its exact colour survives. With `inlineFormatting` off (no span to hold it)
+                        // even a coloured highlight degrades to `==` rather than being dropped. In
+                        // GFM/CommonMark `==` is literal, so a highlight falls through to the <span> path.
+                        const isDefaultHighlight = node.formatting.backgroundColor === '#ffff00';
+                        const emitHighlightMark = !!node.formatting.backgroundColor && this.resolvedDialect.highlight !== 'none'
+                            && (isDefaultHighlight || !this.resolvedFallbackToHtml.inlineFormatting);
+                        if (emitHighlightMark)
+                            text = `==${text}==`;
                         // Use HTML tags for formatting not natively supported by standard Markdown
                         if (this.resolvedFallbackToHtml.textFormatting) {
                             if (node.formatting.underline)
@@ -294,14 +348,18 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                                     styles.push(`${prop}: ${safe}`);
                             };
                             pushStyle('color', node.formatting.color);
-                            pushStyle('background-color', node.formatting.backgroundColor);
+                            // Skip the background-color only when it was already emitted as `==text==`
+                            // above; a specific-colour highlight in a highlight dialect still keeps its
+                            // exact colour here.
+                            if (!emitHighlightMark)
+                                pushStyle('background-color', node.formatting.backgroundColor);
                             pushStyle('font-size', node.formatting.size);
                             if (styles.length)
                                 text = `<span style="${styles.join('; ')}">${text}</span>`;
                         }
                     }
                     const meta = node.metadata;
-                    if (meta?.wikilink && this.resolvedDialect.wikilinks) {
+                    if (meta?.wikilink && this.resolvedDialect.wikilinks !== 'none') {
                         // Obsidian syntax: bare page name, or page|alias when the display
                         // text differs from the page name. Strip the `[]|`/newline chars
                         // that would break out of the `[[...]]` wrapper.
@@ -327,8 +385,11 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                                 link = '#' + this.slugify(target);
                             }
                             // Reject javascript:/data: schemes and encode `()`/whitespace so the
-                            // URL can't break out of `](...)` or inject a script link.
-                            text = `[${text}](${(0, sanitize_js_1.sanitizeMarkdownUrl)(link)})`;
+                            // URL can't break out of `](...)` or inject a script link. An advisory
+                            // title follows as `"title"` (quotes inside it escaped), matching what
+                            // the parser reads back.
+                            const linkTitle = meta.title ? ` "${meta.title.replace(/"/g, '\\"')}"` : '';
+                            text = `[${text}](${(0, sanitize_js_1.sanitizeMarkdownUrl)(link)}${linkTitle})`;
                         }
                     }
                     if (meta?.abbreviationTitle) {
@@ -345,7 +406,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                         // this branch also replaces `text` wholesale, so a strip that left `<`
                         // behind discarded the escaping applied earlier.
                         const key = String(meta.citationKey).replace(/[^a-zA-Z0-9_:.-]/g, '');
-                        text = this.resolvedDialect.citations ? `[@${key}]` : `[${key}]`;
+                        text = this.resolvedDialect.citations !== 'none' ? `[@${key}]` : `[${key}]`;
                     }
                     return text;
                 }
@@ -395,7 +456,17 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                         ? (meta.checked ? `${bullet}[x] ` : `${bullet}[ ] `)
                         : (meta?.listType === 'ordered' ? `${(meta.itemIndex ?? 0) + 1}${this.resolvedDialect.orderedListMarker} ` : bullet);
                     const anchors = this.renderAnchors(meta);
-                    return `${indent}${marker}${anchors}${childrenOutput}\n`;
+                    // A list item is a single Markdown line. HTML-origin items carry `paragraph`
+                    // children (e.g. `<li><p>a</p><ul>...`), whose renderer appends `\n\n`; dumped
+                    // verbatim that produces `- a\n\n\n    - a1`, whose blank line splits the list
+                    // apart and whose indent is then stripped on reparse, flattening the nesting.
+                    // Collapse the item's internal breaks the same way table cells do (see the
+                    // `cellLineBreaks` handling in renderMarkdownTable): join with `<br>` when the
+                    // fallback is on, a space when off. Block children (code fences, tables) inside
+                    // an item degrade under this join, exactly as they do inside a cell.
+                    const br = this.resolvedFallbackToHtml.itemLineBreaks ? '<br>' : ' ';
+                    const content = childrenOutput.trim().replace(/[ \t]*\n+/g, br);
+                    return `${indent}${marker}${anchors}${content}\n`;
                 }
                 case 'image': {
                     if (!this.config.includeImages)
@@ -414,7 +485,8 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     // Strip `[]` from alt (would close the `![...]`) and neutralize the URL scheme.
                     const safeAlt = (0, sanitize_js_1.markdownEscapeText)(alt).replace(/[[\]]/g, '');
                     const safeSrc = (0, sanitize_js_1.sanitizeMarkdownUrl)(src, { allowDataImage: true });
-                    return `${anchors}${anchors ? '\n' : ''}![${safeAlt}](${safeSrc})${this.renderAttributeList(meta)}`;
+                    const imgTitle = meta?.title ? ` "${meta.title.replace(/"/g, '\\"')}"` : '';
+                    return `${anchors}${anchors ? '\n' : ''}![${safeAlt}](${safeSrc}${imgTitle})${this.renderAttributeList(meta)}`;
                 }
                 case 'table': {
                     const anchors = this.renderAnchors(node.metadata);
@@ -424,7 +496,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     // only the plain pipe-table form needs the attribute-list syntax for alignment.
                     const usedHtmlFallback = this.resolvedDialect.tables === 'html' ||
                         (this.resolvedFallbackToHtml.tables && (this.hasNestedTable(node) || this.hasColspanOrRowspan(node)));
-                    const attrList = usedHtmlFallback ? '' : this.renderAttributeList(node.metadata);
+                    const attrList = usedHtmlFallback ? '' : this.renderAttributeList(node.metadata, { skipAlign: true });
                     if (attrList) {
                         // Must glue directly below the last row with no blank line, or
                         // MarkdownParser's block splitter won't see it as part of the same block.
@@ -478,17 +550,20 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                         return this.resolvedDialect.math === 'dollar' ? `$${mathInline}$` : mathInline;
                     }
                     const lang = (meta?.language || '').replace(/[\r\n`]+/g, '');
-                    // Block code if it contains a line break, else inline. Testing only for `\n`
-                    // routed a CR-only string to the inline branch, where a renderer that
-                    // normalizes `\r` to a line ending sees a blank line, the span dies, and the
-                    // remainder is exposed as raw Markdown. The fence sizing below is correct and
-                    // needs no change; code content itself is not an HTML context.
-                    if (node.text && /[\r\n]/.test(node.text)) {
+                    // A `code` node is always block-level: genuinely inline code is a monospace
+                    // text node, never a `code` node. So emit a fenced block whenever the node
+                    // carries a language OR spans multiple lines. Previously the decision keyed only
+                    // off a line break, so a single-line code node with a language - `const x = 1;`
+                    // tagged `js`, or a one-line `mermaid` diagram - collapsed to an inline span,
+                    // silently dropping both its language and its block-ness. (Testing `[\r\n]`, not
+                    // just `\n`, still routes a CR-only body to the fenced branch, where a renderer
+                    // that normalizes `\r` to a line ending would otherwise kill an inline span.)
+                    if (lang || (node.text && /[\r\n]/.test(node.text))) {
                         // Fence with one more backtick than the longest run inside the content
                         // so an embedded ``` can't close the block early and inject markup.
-                        const longestRun = Math.max(0, ...(node.text.match(/`+/g) || []).map(s => s.length));
+                        const longestRun = Math.max(0, ...((node.text || '').match(/`+/g) || []).map(s => s.length));
                         const fence = '`'.repeat(Math.max(3, longestRun + 1));
-                        return `\n${fence}${lang}\n${node.text}\n${fence}\n\n`;
+                        return `\n${fence}${lang}\n${node.text || ''}\n${fence}\n\n`;
                     }
                     else {
                         const t = node.text || '';
@@ -514,7 +589,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                 case 'note': {
                     const meta = node.metadata;
                     if (meta?.noteType === 'footnote' || meta?.noteType === 'endnote') {
-                        if (!this.resolvedDialect.footnotes) {
+                        if (this.resolvedDialect.footnotes === 'none') {
                             // Dialect has no footnote syntax - the caller inlines this bare body
                             // as a parenthetical at the reference point instead of collecting it
                             // into an end-of-document "### Notes" section under a [^id] marker.
@@ -570,12 +645,12 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     const title = meta?.title ? (0, sanitize_js_1.markdownEscapeText)(foldLines(meta.title)) : '';
                     const body = childrenOutput.trim();
                     switch (this.resolvedDialect.admonitions) {
-                        case 'gitlab':
+                        case 'fence':
                             // GLFM fenced-div: no dedicated title syntax, so a custom title (if
                             // any) is folded into the body as a bold first line.
                             return `:::${type}\n${title ? `**${title}**\n\n` : ''}${body}\n:::\n\n`;
-                        case 'pandoc':
-                            // Pandoc's own fenced-div-with-class syntax; same title handling as gitlab.
+                        case 'fence-attribute':
+                            // Pandoc's own fenced-div-with-class syntax; same title handling as fence.
                             return `::: {.${type}}\n${title ? `**${title}**\n\n` : ''}${body}\n:::\n\n`;
                         case 'none': {
                             // Degrade to a plain bold-labeled blockquote, no special marker.
@@ -583,7 +658,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                             const heading = title || label.charAt(0) + label.slice(1).toLowerCase();
                             return `> **${heading}:**\n${quotedLines}\n\n`;
                         }
-                        case 'github':
+                        case 'blockquote':
                         default: {
                             // Canonical GitHub blockquote form. No dedicated title syntax either
                             // (matches this library's historical output).
@@ -593,15 +668,15 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     }
                 }
                 case 'definitionList':
-                    if (!this.resolvedDialect.definitionLists)
+                    if (this.resolvedDialect.definitionLists === 'none')
                         return `${childrenOutput}\n`;
                     return `${childrenOutput}\n`;
                 case 'definitionTerm':
-                    if (!this.resolvedDialect.definitionLists)
+                    if (this.resolvedDialect.definitionLists === 'none')
                         return `**${childrenOutput}**\n\n`;
                     return `${childrenOutput}\n`;
                 case 'definitionDescription':
-                    if (!this.resolvedDialect.definitionLists)
+                    if (this.resolvedDialect.definitionLists === 'none')
                         return `${childrenOutput}\n\n`;
                     return `: ${childrenOutput}\n`;
                 case 'chart':
@@ -716,7 +791,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
         // end-of-document "### Notes" section, or its content would be duplicated.
         const isInlinedFootnote = (note) => {
             const meta = note.metadata;
-            return (meta?.noteType === 'footnote' || meta?.noteType === 'endnote') && !this.resolvedDialect.footnotes;
+            return (meta?.noteType === 'footnote' || meta?.noteType === 'endnote') && this.resolvedDialect.footnotes === 'none';
         };
         this.collectNotesFrom(node);
         let result = await processor(node, childrenOutput);
@@ -832,7 +907,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
             return;
         const isInlinedFootnote = (note) => {
             const meta = note.metadata;
-            return (meta?.noteType === 'footnote' || meta?.noteType === 'endnote') && !this.resolvedDialect.footnotes;
+            return (meta?.noteType === 'footnote' || meta?.noteType === 'endnote') && this.resolvedDialect.footnotes === 'none';
         };
         this.collectedNotes.push(...node.notes.filter(note => !isInlinedFootnote(note)));
     }
@@ -876,7 +951,9 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                         let cellContent = await this.processNodeRecursive(cellNode, processor);
                         // Use <br> fallback only if allowed, otherwise space
                         const br = this.resolvedFallbackToHtml.cellLineBreaks ? '<br>' : ' ';
-                        cellContent = cellContent.trim().replace(/\n+/g, br).replace(/\|/g, '\\|');
+                        // Consume any trailing spaces before the newline(s) too, so a hard-break's
+                        // `  \n` collapses to a single `<br>` instead of leaving `  <br>` in the cell.
+                        cellContent = cellContent.trim().replace(/[ \t]*\n+/g, br).replace(/\|/g, '\\|');
                         rowCells.push(cellContent);
                         // Handle colspan by adding empty cells
                         const colSpan = cellNode.metadata?.colSpan || 1;
@@ -893,7 +970,17 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                 this.inImplicitBold = wasInImplicitBold;
             }
         }
-        // Second pass: Build table string with separator
+        // Second pass: Build table string with separator. The separator carries standard GFM
+        // per-column alignment (`:---`/`:---:`/`---:`) from columnAlignments, or the single table-level
+        // align applied to every column, rather than a non-standard trailing `{align}` attribute list.
+        const tableMeta = node.metadata;
+        // Column alignment lives on each cell (CellMetadata.align); read it off the header row.
+        // Fall back to the single table-level align (an editor's data-align) for every column.
+        const headerCells = (node.children?.[0]?.children || []).filter(c => c.type === 'cell');
+        const alignMarker = (i) => {
+            const a = headerCells[i]?.metadata?.align ?? tableMeta?.align;
+            return a === 'center' ? ':---:' : a === 'left' ? ':---' : a === 'right' ? '---:' : '---';
+        };
         for (let i = 0; i < processedRows.length; i++) {
             const row = processedRows[i];
             // Pad row with empty cells if it has fewer than maxCols
@@ -902,7 +989,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
             tableOutput += `| ${row.join(' | ')} |\n`;
             if (i === 0) {
                 // Header separator
-                tableOutput += `| ${Array(maxCols).fill(' --- ').join(' | ')} |\n`;
+                tableOutput += `| ${Array.from({ length: maxCols }, (_, i) => alignMarker(i)).join(' | ')} |\n`;
             }
         }
         return `\n${tableOutput}\n`;